home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 223_01 / cc42.c < prev    next >
Text File  |  1980-01-01  |  7KB  |  324 lines
  1. /*
  2. ** add primary and secondary registers (result in primary)
  3. */
  4. ffadd() {ol("DAD D");}
  5.  
  6. /*
  7. ** subtract primary from secondary register (result in primary)
  8. */
  9. ffsub() {ffcall("CCSUB##");}
  10.  
  11. /*
  12. ** multiply primary and secondary registers (result in primary)
  13. */
  14. ffmult() {ffcall("CCMULT##");}
  15.  
  16. /*
  17. ** divide secondary by primary register
  18. ** (quotient in primary, remainder in secondary)
  19. */
  20. ffdiv() {ffcall("CCDIV##");}
  21.  
  22. /*
  23. ** remainder of secondary/primary
  24. ** (remainder in primary, quotient in secondary)
  25. */
  26. ffmod() {ffdiv();swap();}
  27.  
  28. /*
  29. ** inclusive "or" primary and secondary registers
  30. ** (result in primary)
  31. */
  32. ffor() {ffcall("CCOR##");}
  33.  
  34. /*
  35. ** exclusive "or" the primary and secondary registers
  36. ** (result in primary)
  37. */
  38. ffxor() {ffcall("CCXOR##");}
  39.  
  40. /*
  41. ** "and" primary and secondary registers
  42. ** (result in primary)
  43. */
  44. ffand() {ffcall("CCAND##");}
  45.  
  46. /*
  47. ** logical negation of primary register
  48. */
  49. lneg() {ffcall("CCLNEG##");}
  50.  
  51. /*
  52. ** arithmetic shift right secondary register
  53. ** number of bits given in primary register
  54. ** (result in primary)
  55. */
  56. ffasr() {ffcall("CCASR##");}
  57.  
  58. /*
  59. ** arithmetic shift left secondary register
  60. ** number of bits given in primary register
  61. ** (result in primary)
  62. */
  63. ffasl() {ffcall("CCASL##");}
  64.  
  65. /*
  66. ** two's complement primary register
  67. */
  68. neg() {ffcall("CCNEG##");}
  69.  
  70. /*
  71. ** one's complement primary register
  72. */
  73. com() {ffcall("CCCOM##");}
  74.  
  75. /*
  76. ** multi dimensional array index generater        fas 2.6
  77. */
  78.  
  79. getmd(mdval) int mdval;{
  80.   push();        /* save sum              fas 2.6 */
  81.   immed();        /* LXI H,            fas 2.6 */
  82.   outdec(mdval);    /*   with index            fas 2.6 */
  83.   nl();            /*                fas 2.6 */
  84.   ffmult();        /* multiply by subscript    fas 2.6 */
  85.   pop();        /* retrieve sum            fas 2.6 */
  86. }
  87.  
  88. /*
  89. ** increment primary register by one object of whatever size
  90. */
  91. inc(n) int n; {
  92.   while(1) {
  93.     ol("INX H");
  94.     if(--n < 1) break;
  95.     }
  96.   }
  97.  
  98. /*
  99. ** decrement primary register by one object of whatever size
  100. */
  101. dec(n) int n; {
  102.   while(1) {
  103.     ol("DCX H");
  104.     if(--n < 1) break;
  105.     }
  106.   }
  107.  
  108. /*
  109. ** test for equal to
  110. */
  111. ffeq()  {ffcall("CCEQ##");}
  112.  
  113. /*
  114. ** test for equal to zero
  115. */
  116. eq0(label) int label; {
  117.   ol("MOV A,H");
  118.   ol("ORA L");
  119.   ot("JNZ ");
  120.   printlabel(label);
  121.   nl();
  122.   }
  123.  
  124. /*
  125. ** test for not equal to
  126. */
  127. ffne()  {ffcall("CCNE##");}
  128.  
  129. /*
  130. ** test for not equal to zero
  131. */
  132. ne0(label) int label; {
  133.   ol("MOV A,H");
  134.   ol("ORA L");
  135.   ot("JZ ");
  136.   printlabel(label);
  137.   nl();
  138.   }
  139.  
  140. /*
  141. ** test for less than (signed)
  142. */
  143. fflt()  {ffcall("CCLT##");}
  144.  
  145. /*
  146. ** test for less than to zero
  147. */
  148. lt0(label) int label; {
  149.   ol("XRA A");
  150.   ol("ORA H");
  151.   ot("JP ");
  152.   printlabel(label);
  153.   nl();
  154.   }
  155.  
  156. /*
  157. ** test for less than or equal to (signed)
  158. */
  159. ffle()  {ffcall("CCLE##");}
  160.  
  161. /*
  162. ** test for less than or equal to zero
  163. */
  164. le0(label) int label; {
  165.   ol("MOV A,H");
  166.   ol("ORA L");
  167.   ol("JZ $+8");
  168.   ol("XRA A");
  169.   ol("ORA H");
  170.   ot("JP ");
  171.   printlabel(label);
  172.   nl();
  173.   }
  174.  
  175. /*
  176. ** test for greater than (signed)
  177. */
  178. ffgt()  {ffcall("CCGT##");}
  179.  
  180. /*
  181. ** test for greater than to zero
  182. */
  183. gt0(label) int label; {
  184.   ol("XRA A");
  185.   ol("ORA H");
  186.   ot("JM ");
  187.   printlabel(label);
  188.   nl();
  189.   ol("ORA L");
  190.   ot("JZ ");
  191.   printlabel(label);
  192.   nl();
  193.   }
  194.  
  195. /*
  196. ** test for greater than or equal to (signed)
  197. */
  198. ffge()  {ffcall("CCGE##");}
  199.  
  200. /*
  201. ** test for gteater than or equal to zero
  202. */
  203. ge0(label) int label; {
  204.   ol("XRA A");
  205.   ol("ORA H");
  206.   ot("JM ");
  207.   printlabel(label);
  208.   nl();
  209.   }
  210.  
  211. /*
  212. ** test for less than (unsigned)
  213. */
  214. ult()  {ffcall("CCULT##");}
  215.  
  216. /*
  217. ** test for less than to zero (unsigned)
  218. */
  219. ult0(label) int label; {
  220.   ot("JMP ");
  221.   printlabel(label);
  222.   nl();
  223.   }
  224.  
  225. /*
  226. ** test for less than or equal to (unsigned)
  227. */
  228. ule()  {ffcall("CCULE##");}
  229.  
  230. /*
  231. ** test for greater than (unsigned)
  232. */
  233. ugt()  {ffcall("CCUGT##");}
  234.  
  235. /*
  236. ** test for greater than or equal to (unsigned)
  237. */
  238. uge()  {ffcall("CCUGE##");}
  239.  
  240. #ifdef OPTIMIZE
  241. peephole(ptr) char *ptr; {
  242.   while(*ptr) {
  243.     if(streq(ptr,"LXI H,0\nDAD SP\nCALL CCGINT##")) {
  244.       if(streq(ptr+29, "XCHG;;")) {pp2();ptr=ptr+36;}
  245.       else                        {pp1();ptr=ptr+29;}
  246.       }
  247.     else if(streq(ptr,"LXI H,2\nDAD SP\nCALL CCGINT##")) {
  248.       if(streq(ptr+29, "XCHG;;")) {pp3(pp2);ptr=ptr+36;}
  249.       else                        {pp3(pp1);ptr=ptr+29;}
  250.       }
  251.     else if(optimize) {
  252.       if(streq(ptr, "DAD SP\nCALL CCGINT##")) {
  253.         ol("CALL CCDSGI##");
  254.         ptr=ptr+21;
  255.         }
  256.       else if(streq(ptr, "DAD D\nCALL CCGINT##")) {
  257.         ol("CALL CCDDGI##");
  258.         ptr=ptr+20;
  259.         }
  260.       else if(streq(ptr, "DAD SP\nCALL CCGCHAR##")) {
  261.         ol("CALL CCDSGC##");
  262.         ptr=ptr+22;
  263.           }
  264.       else if(streq(ptr, "DAD D\nCALL CCGCHAR##")) {
  265.         ol("CALL CCDDGC##");
  266.         ptr=ptr+21;
  267.         }
  268.       else if(streq(ptr,
  269. "DAD SP\nMOV D,H\nMOV E,L\nCALL CCGINT##\nINX H\nCALL CCPINT##")) {
  270.         ol("CALL CCINCI##");
  271.         ptr=ptr+57;
  272.         }
  273.       else if(streq(ptr,
  274. "DAD SP\nMOV D,H\nMOV E,L\nCALL CCGINT##\nDCX H\nCALL CCPINT##")) {
  275.         ol("CALL CCDECI##");
  276.         ptr=ptr+57;
  277.         }
  278.       else if(streq(ptr,
  279. "DAD SP\nMOV D,H\nMOV E,L\nCALL CCGCHAR##\nINX H\nMOV A,L\nSTAX D")) {
  280.         ol("CALL CCINCC##");
  281.         ptr=ptr+59;
  282.         }
  283.       else if(streq(ptr,
  284. "DAD SP\nMOV D,H\nMOV E,L\nCALL CCGCHAR##\nDCX H\nMOV A,L\nSTAX D")) {
  285.         ol("CALL CCDECC##");
  286.         ptr=ptr+59;
  287.         }
  288.       else if(streq(ptr, "DAD D\nPOP D\nCALL CCPINT##")) {
  289.         ol("CALL CDPDPI##");
  290.         ptr=ptr+26;
  291.         }
  292.       else if(streq(ptr, "DAD D\nPOP D\nMOV A,L\nSTAX D")) {
  293.         ol("CALL CDPDPC##");
  294.         ptr=ptr+27;
  295.         }
  296.       else if(streq(ptr, "POP D\nCALL CCPINT##")) {
  297.         ol("CALL CCPDPI##");
  298.         ptr=ptr+20;
  299.         }
  300.                                                  /*30*/
  301.       /* additional optimizing logic goes here */
  302.       else cout(*ptr++, output);
  303.       }
  304.     else cout(*ptr++, output);
  305.     }
  306.   }
  307.  
  308. pp1() {
  309.   ol("POP H");
  310.   ol("PUSH H");
  311.   }
  312.  
  313. pp2() {
  314.   ol("POP D");
  315.   ol("PUSH D");
  316.   }
  317.  
  318. pp3(pp) int (*pp)(); {                                  /*13*/
  319.   ol("POP B");
  320.   (*pp)();                                              /*13*/
  321.   ol("PUSH B");
  322.   }
  323. #endif
  324.